package com.loong.android.tools;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.text.Html;
import android.text.Spanned;

import java.io.UnsupportedEncodingException;

/**
 * 文本操作
 */
public class Text {

    /**
     * 获取文本的字符个数。
     *
     * @param content 待获取的文本。
     */
    public static int length(String content) {
        if (content == null) return 0;
        return content.length();
    }

    /**
     * 获取文本占用的字节数量。
     *
     * @param content 待获取的文本
     */
    public static int byteLength(String content) {
        if (content == null) return 0;
        return content.getBytes().length;
    }

    /**
     * 取文本字节数组。
     *
     * @param content 待获取的文本
     */
    public static byte[] getBytes(String content) {
        if (content == null) return null;
        return content.getBytes();
    }

    /**
     * 字节数组转文本
     *
     * @param bytes 字节数组
     */
    public static String toString(byte[] bytes) {
        return new String(bytes);
    }

    /**
     * 字节数组转文本
     *
     * @param bytes       字节数组
     * @param charsetName 编码名称，如utf8、gbk等
     */
    public static String toString(byte[] bytes, String charsetName) {
        try {
            return new String(bytes, charsetName);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 字节数组转文本
     *
     * @param bytes      字节数组TextDecoder Polyfill
     * @param startIndex 起始位置
     * @param len        长度
     */
    public static String toString(byte[] bytes, int startIndex, int len) {
        return new String(bytes, startIndex, len);
    }

    /**
     * 字节数组转文本
     *
     * @param bytes       字节数组
     * @param startIndex  起始位置
     * @param len         长度
     * @param charsetName 编码名称
     */
    public static String toString(byte[] bytes, int startIndex, int len, String charsetName) {
        try {
            return new String(bytes, startIndex, len, charsetName);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 逻辑型转文本
     *
     * @param data 数据
     */
    public static String toString(boolean data) {
        return String.valueOf(data);
    }

    /**
     * 字节转文本
     *
     * @param data 数据
     */
    public static String toString(byte data) {
        return String.valueOf(data);
    }

    /**
     * 短整数型转文本
     *
     * @param data 数据
     */
    public static String toString(short data) {
        return String.valueOf(data);
    }

    /**
     * 整数型转文本
     *
     * @param data 数据
     */
    public static String toString(int data) {
        return String.valueOf(data);
    }

    /**
     * 长整数型转文本
     *
     * @param data 数据
     */
    public static String toString(long data) {
        return String.valueOf(data);
    }

    /**
     * 小数型转文本
     *
     * @param data 数据
     */
    public static String toString(float data) {
        return String.valueOf(data);
    }

    /**
     * 长小数型转文本
     *
     * @param data 数据
     */
    public static String toString(double data) {
        return String.valueOf(data);
    }

    /**
     * 字符数组转文本
     *
     * @param chars 字符数组
     */
    public static String toString(char[] chars) {
        return String.valueOf(chars);
    }

    /**
     * 字节数组转十六进制文本
     *
     * @param bytes 字节数组
     */
    public static String toHexString(byte[] bytes) {
        if(bytes == null) return null;
        int i, j, in;
        String[] hex = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
        StringBuilder out = new StringBuilder();
        for (j = 0; j < bytes.length; ++j) {
            in = (int) bytes[j] & 0xff;
            i = (in >> 4) & 0x0f;
            out.append(hex[i]);
            i = in & 0x0f;
            out.append(hex[i]);
        }
        return out.toString();
    }

    /**
     * 从文本左边截取字符
     *
     * @param content  待获取的文本
     * @param charSize 获取的字符数
     */
    public static String getLeft(String content, int charSize) {
        if (content == null || content.equals("")) return "";
        if (charSize <= 0) return "";
        if (charSize > content.length()) return content;
        return content.substring(0, charSize);
    }

    /**
     * 按字节数从文本左边截取字符
     *
     * @param content  待获取的文本
     * @param byteSize 字节数
     */
    public static String getLeftByByteSize(String content, int byteSize) {
        if (content == null || content.equals("")) return "";
        if (byteSize <= 0) return "";
        byte[] b = content.getBytes();
        if (byteSize > b.length) return content;
        byte[] out = new byte[byteSize];
        System.arraycopy(b, 0, out, 0, byteSize);
        return new String(out);
    }

    /**
     * 从文本右边截取字符
     *
     * @param content  待获取的内容
     * @param charSize 字符数
     */
    public static String getRight(String content, int charSize) {
        if (content == null || content.equals("")) return "";
        if (charSize <= 0) return "";
        int len = content.length();
        if (charSize > len) return content;
        return content.substring(len - charSize, len);
    }

    /**
     * 按字节数从文本右边截取字符
     *
     * @param content  待获取的文本
     * @param byteSize 字节数
     */
    public static String getRightByByteSize(String content, int byteSize) {
        if (content == null || content.equals("")) return "";
        if (byteSize <= 0) return "";
        byte[] b = content.getBytes();
        int len = b.length;
        if (byteSize > len) return content;
        byte[] out = new byte[byteSize];
        System.arraycopy(b, len - byteSize, out, 0, byteSize);
        return new String(out);
    }

    /**
     * 截取文本字符
     *
     * @param content    待获取的文本
     * @param startIndex 起始位置，从0开始计算
     * @param charSize   字符数
     */
    public static String substr(String content, int startIndex, int charSize) {
        if (content == null || content.equals("")) return "";
        if (charSize <= 0) return "";
        if (startIndex < 0) startIndex = 0;
        int len = content.length();
        if (startIndex >= len) return "";
        if (startIndex + charSize > len) charSize = len - startIndex;
        return content.substring(startIndex, startIndex + charSize);
    }

    /**
     * 截取文本字符
     *
     * @param content    待获取的文本
     * @param startIndex 起始位置，从0开始计算
     * @param endIndex   结束位置
     */
    public static String substring(String content, int startIndex, int endIndex) {
        if (content == null || content.equals("")) return "";
        if (startIndex < 0) startIndex = 0;
        int len = content.length();
        if (endIndex > len) endIndex = len;
        if (endIndex <= startIndex) return "";
        return content.substring(startIndex, endIndex);
    }

    /**
     * 按字节截取文本
     *
     * @param content    待获取的文本
     * @param startIndex 起始位置
     * @param byteSize   字节数
     */
    public static String substrByByteSize(String content, int startIndex, int byteSize) {
        if (content == null || content.equals("")) return "";
        if (byteSize <= 0) return "";
        if (startIndex < 0) startIndex = 0;
        byte[] b = content.getBytes();
        int len = b.length;
        if (startIndex >= len) return "";
        if (startIndex + byteSize > len) byteSize = len - startIndex;
        byte[] out = new byte[byteSize];
        System.arraycopy(b, startIndex, out, 0, byteSize);
        return new String(out);
    }

    /**
     * 获取两者间的文本
     *
     * @param content  待获取的文本
     * @param leftStr  左边的文本
     * @param rightStr 右边的文本
     */
    public static String between(String content, String leftStr, String rightStr) {
        if (content == null || content.equals("")) return "";
        if (leftStr == null || leftStr.equals("")) return "";
        if (rightStr == null || rightStr.equals("")) return "";
        int pos1 = content.indexOf(leftStr);
        if (pos1 < 0) return "";
        int pos2 = content.indexOf(rightStr, pos1 + 1);
        if (pos2 < 0) return "";
        return content.substring(pos1 + length(leftStr), pos2);
    }

    /**
     * 查找字符串在文本中首次出现的位置，未找到则返回-1
     *
     * @param srcContent  操作的原文本
     * @param destContent 查找的文本
     */
    public static int indexOf(String srcContent, String destContent) {
        return indexOf(srcContent, destContent, 0);
    }

    /**
     * 查找字符串在文本中首次出现的位置，未找到则返回-1
     *
     * @param srcContent  操作的原文本
     * @param destContent 查找的文本
     * @param fromIndex   起始位置
     */
    public static int indexOf(String srcContent, String destContent, int fromIndex) {
        if (srcContent == null || srcContent.equals("")) return -1;
        if (destContent == null || destContent.equals("")) return -1;
        if (fromIndex < 0) fromIndex = 0;
        int len = srcContent.length();
        if (fromIndex >= len) return -1;
        return srcContent.indexOf(destContent, fromIndex);
    }

    /**
     * 查找字符串在文本中最后出现的位置，未找到则返回-1
     *
     * @param srcContent  操作的原文本
     * @param destContent 查找的文本
     */
    public static int lastIndexOf(String srcContent, String destContent) {
        return lastIndexOf(srcContent, destContent, length(srcContent));
    }

    /**
     * 查找字符串在文本中最后出现的位置，未找到则返回-1
     *
     * @param srcContent  操作的原文本
     * @param destContent 查找的文本
     * @param fromIndex   起始位置
     */
    public static int lastIndexOf(String srcContent, String destContent, int fromIndex) {
        if (srcContent == null || srcContent.equals("")) return -1;
        if (destContent == null || destContent.equals("")) return -1;
        if (fromIndex < 0) fromIndex = 0;
        int len = srcContent.length();
        if (fromIndex >= len) fromIndex = len - 1;
        return srcContent.lastIndexOf(destContent, fromIndex);
    }

    /**
     * 转为大写
     *
     * @param content 操作的原文本
     */
    public static String toUpperCase(String content) {
        if (content == null || content.equals("")) return "";
        return content.toUpperCase();
    }

    /**
     * 转为小写
     *
     * @param content 操作的原文本
     */
    public static String toLowerCase(String content) {
        if (content == null || content.equals("")) return "";
        return content.toLowerCase();
    }

    /**
     * 删除开头的空格
     *
     * @param content 操作的原文本
     */
    public static String trimStart(String content) {
        if (content == null || content.equals("")) return "";
        return content.replaceAll("^ +", "");
    }

    /**
     * 删除结尾的空格
     *
     * @param content 操作的原文本
     */
    public static String trimEnd(String content) {
        if (content == null || content.equals("")) return "";
        return content.replaceAll(" +$", "");
    }

    /**
     * 删除开头和结尾的空格
     *
     * @param content 操作的原文本
     */
    public static String trim(String content) {
        if (content == null || content.equals("")) return "";
        return content.trim();
    }

    /**
     * 删除全部的空格
     *
     * @param content 操作的原文本
     */
    public static String trimAll(String content) {
        if (content == null || content.equals("")) return "";
        return content.replaceAll(" +", "");
    }

    /**
     * 分割文本，特殊字符需要在前面加上\\。比如点号(.)、|等,如果分隔符是斜杠(\)，应该这么写"\\\\",分隔符是2个斜杠就填"\\\\\\\\"
     *
     * @param srcContent   操作的原文本
     * @param splitContent 用作分割的文本
     */
    public static String[] split(String srcContent, String splitContent) {
        if (srcContent == null || srcContent.length() <= 0) return new String[0];
        if (splitContent == null || splitContent.length() <= 0) return new String[]{srcContent};
        return srcContent.split(splitContent);
    }

    /**
     * 替换
     *
     * @param srcContent  操作的原文本
     * @param target      需替换的文本
     * @param replacement 用作替换的文本
     */
    public static String replace(String srcContent, String target, String replacement) {
        if (srcContent == null || srcContent.equals("")) return "";
        if (target == null || target.equals("")) return srcContent;
        if (replacement == null) return srcContent;
        return srcContent.replace(target, replacement);
    }

    /**
     * 从指定位置替换指定字符数的文本
     *
     * @param srcContent  操作的原文本
     * @param replacement 用作替换的文本
     * @param startIndex  起始位置
     * @param charSize    字符数
     */
    public static String replace(String srcContent, String replacement, int startIndex, int charSize) {
        if (srcContent == null || srcContent.equals("")) return "";
        if (replacement == null) return srcContent;
        if (charSize <= 0) return srcContent;
        if (startIndex < 0) startIndex = 0;
        int len = srcContent.length();
        if (startIndex >= len) return srcContent;
        if (startIndex + charSize > len) charSize = len - startIndex;
        return srcContent.substring(0, startIndex) + replacement + srcContent.substring(startIndex + charSize, len);
    }

    /**
     * 是否为数值
     *
     * @param content 文本内容
     */
    public static boolean isNumber(String content) {
        return !(content == null || content.equals("")) && content.matches("^[-+]?[0-9]+(\\.[0-9]+)?$");
    }

    /**
     * 是否为负数
     *
     * @param content 文本内容
     */
    public static boolean isMinusNumber(String content) {
        return !(content == null || content.equals("")) && content.matches("^-[0-9]+(\\.[0-9]+)?$");
    }

    /**
     * 是否为正数
     *
     * @param content 文本内容
     */
    public static boolean isPlusNumber(String content) {
        return !(content == null || content.equals("")) && content.matches("^\\+?[0-9]+(\\.[0-9]+)?$");
    }

    /**
     * 是否为整数
     *
     * @param content 文本内容
     */
    public static boolean isInteger(String content) {
        return !(content == null || content.equals("")) && content.matches("^[-+]?[0-9]+$");
    }

    /**
     * 是否为正整数
     *
     * @param content 文本内容
     */
    public static boolean isPlusInteger(String content) {
        return !(content == null || content.equals("")) && content.matches("^\\+?[0-9]+$");
    }

    /**
     * 是否为负整数
     *
     * @param content 文本内容
     */
    public static boolean isMinusInteger(String content) {
        return !(content == null || content.equals("")) && content.matches("^-[0-9]+$");
    }

    /**
     * 是否为小数
     *
     * @param content 文本内容
     */
    public static boolean isFloat(String content) {
        return !(content == null || content.equals("")) && content.matches("^[-+]?[0-9]+(\\.[0-9]+)+$");
    }

    /**
     * 是否为正小数
     *
     * @param content 文本内容
     */
    public static boolean isPlusFloat(String content) {
        return !(content == null || content.equals("")) && content.matches("\\+?[0-9]+(\\.[0-9]+)+$");
    }

    /**
     * 是否为负小数
     *
     * @param content 文本内容
     */
    public static boolean isMinusFloat(String content) {
        return !(content == null || content.equals("")) && content.matches("-[0-9]+(\\.[0-9]+)+$");
    }

    /**
     * 是否为汉字(\u4e00-\u9fa5)
     *
     * @param content 文本内容
     */
    public static boolean isChinese(String content) {
        return !(content == null || content.equals("")) && content.matches("^[\\u4e00-\\u9fa5]+$");
    }

    /**
     * 是否为字母: a-z, A-Z
     *
     * @param content 操作的原文本
     */
    public static boolean isLetter(String content) {
        return !(content == null || content.equals("")) && content.matches("^[a-zA-Z]+$");
    }

    /**
     * 两个文本比较。文本1<文本2=>小于0; 文本1=文本2=>等于0; 文本1>文本2=>大于0
     *
     * @param str1
     * @param str2
     * @return
     */
    public static int compare(String str1, String str2) {
        if (str1 == null) str1 = "";
        if (str2 == null) str2 = "";
        return str1.compareTo(str2);
    }

    /**
     * 判断是否包含某个文本
     *
     * @param srcContent  操作的原文本
     * @param destContent 包含的文本
     */
    public static boolean contains(String srcContent, String destContent) {
        return !(srcContent == null || srcContent.equals("")) && srcContent.contains(destContent);
    }

    /**
     * 是否为空
     *
     * @param content 文本内容
     */
    public static boolean isEmpty(String content) {
        return content == null || content.equals("");
    }

    /**
     * 判断文本是否以某段文本开头
     *
     * @param content 操作的原文本
     * @param prefix  开头的文本
     */
    public static boolean startsWith(String content, String prefix) {
        return !(content == null || content.equals("")) &&
                !(prefix == null || prefix.equals("")) &&
                content.startsWith(prefix);
    }

    /**
     * 判断文本是否以某段文本结束
     *
     * @param content 操作的原文本
     * @param suffix  结束的文本
     */
    public static boolean endsWith(String content, String suffix) {
        return !(content == null || content.equals("")) &&
                !(suffix == null || suffix.equals("")) &&
                content.endsWith(suffix);
    }

    /**
     * 取文本中的字符
     *
     * @param content 操作的原文本
     * @param index   字符位置
     */
    public static char charAt(String content, int index) {
        if (content == null) return 0;
        if (index < 0) return 0;
        if (index >= content.length()) return 0;
        return content.charAt(index);
    }

    /**
     * 文本转字符数组
     *
     * @param content 文本内容
     */
    public static char[] toCharArray(String content) {
        if (content == null || content.equals("")) return new char[0];
        return content.toCharArray();
    }

    /**
     * 文本转为字节
     *
     * @param content 文本内容
     **/
    public static byte toByte(String content) {
        if (content == null || content.equals("")) return 0;
        try {
            int tmp = Integer.valueOf(content);
            if (tmp >= -128 && tmp <= 127) return Byte.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转短整数
     *
     * @param content 文本内容
     **/
    public static short toShort(String content) {
        if (content == null || content.equals("")) return 0;
        try {
            return Short.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转整数
     *
     * @param content 文本内容
     **/
    public static int toInteger(String content) {
        if (content == null || content.equals("")) return 0;
        try {
            return Integer.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转长整数
     *
     * @param content 文本内容
     **/
    public static long toLong(String content) {
        if (content == null || content.equals("")) return 0;
        try {
            return Long.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转小数
     *
     * @param content 文本内容
     **/
    public static float toFloat(String content) {
        if (content == null || content.equals("")) return 0.0F;
        try {
            return Float.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转长小数
     *
     * @param content 文本内容
     **/
    public static double toDouble(String content) {
        if (content == null || content.equals("")) return 0.0D;
        try {
            return Double.valueOf(content);
        } catch (Exception ignore) {
        }
        return 0;
    }

    /**
     * 文本转逻辑型
     *
     * @param content 文本内容
     **/
    public static boolean toBoolean(String content) {
        if (content == null || content.equals("")) return false;
        if (content.equals("真") || content.equals("true")) return true;
        if (content.equals("假") || content.equals("false")) return false;
        return false;
    }

    /**
     * 取超文本对象
     *
     * @param context 上下文
     * @param html    超文本内容
     */
    public static Spanned getHtmlText(Context context, String html) {
        return resolveHtml(context, html, 0, 0);
    }

    /**
     * 取超文本对象
     *
     * @param context   上下文
     * @param html      超文本内容
     * @param imgWidth  图片宽度
     * @param imgHeight 图片高度
     */
    public static Spanned getHtmlText(Context context, String html, int imgWidth, int imgHeight) {
        return resolveHtml(context, html, imgWidth, imgHeight);
    }

    public static Spanned resolveHtml(Context context, String htmlContent, int width, int height) {
        Spanned html;
        if (Build.VERSION.SDK_INT >= 24) {
            html = Html.fromHtml(htmlContent, Html.FROM_HTML_MODE_COMPACT, createImageGetter(context, width, height), null);
        } else {
            html = Html.fromHtml(htmlContent, createImageGetter(context, width, height), null);
        }
        return html;
    }

    public static Html.ImageGetter createImageGetter(Context context, final int width, final int height) {
        return new Html.ImageGetter() {
            public Drawable getDrawable(String source) {
                Drawable drawable = null;
                try {
                    //读取路径图片
                    drawable = Drawable.createFromPath(source);
                    if (drawable != null) {
                        drawable.setBounds(0, 0, width <= 0 ? drawable.getIntrinsicWidth() : width,
                                height <= 0 ? drawable.getIntrinsicHeight() : height);
                        return drawable;
                    }
                    //读取R资源图片
                    int rId = Integer.parseInt(source);
                    if (context == null) return null;
                    drawable = context.getResources().getDrawable(rId);
                    if (drawable != null)
                        drawable.setBounds(0, 0, width <= 0 ? drawable.getIntrinsicWidth() : width,
                                height <= 0 ? drawable.getIntrinsicHeight() : height);
                    return drawable;
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        };
    }
}
